public class Test {

    //java三个特性  ：封装：
    //什么是封装：对垒的细节进行隐藏，提供公开的接口来和数据进行交互
    public static void main1(String[] args) {
        Person person = new Person();
        person.age = 123;
//        person.name = "lisi";
    //name和eat已经被封装起来了，采用private修饰
    //当前权限就变小了，只能在类当中访问
    //想要初始化：可以利用构造方法初始化，但是构造初始化只能赋值一次
    //后面不能改名

    //因此需要提供公开的接口访问被隐藏的成员  setter 和getter  方法
    //快捷键创建公开方法

    }

    public static void main(String[] args) {

        //静态成员不属于对象，属于类，如果不用通过对象来访问，直接通过类名访问。
        // 证明如下：
        Student student1 = new Student("gaobo",10);
        System.out.println(student1.room);
        //不会提示快捷输入
        Student student2 = new Student("gaobo",10);
        Student student3 = null;
        //不属于对象，通过对象来调用就算没有对象也不影响调用
        System.out.println(student3.room);
        System.out.println(Student.room);
        //提示快捷输入

        student3.func();
        Student.func();

    }
}

//静态变声声明周期和类一致，随着类的加载而创建，类的结束而卸载
//每个学生对象有三个属性，但是对于同一个班的人来说，教室这个是共享的，不需要每个人存储一份
//用static修饰room，room将会被放到方法区

//静态数据成员/类成员/类变量/类人猿（bushi）不属于具体的对象，为所有对象共享
//非静态数据成员

//成员方法：
//静态成员方法
//非静态成员方法
class Student {
    public String name;
    public int age;
    public static String room;

    public void doClass() {
        func();
        System.out.println("class");

    }

    public Student(String name,int age) {

        this.name = name;
        this.age = age;
    }

    public static void func() {
        System.out.println("static");

    }

}
class Person {
    private String name;
    public int age;

    public void shou() {
        System.out.println(name + age);
    }

    private void eat() {
        System.out.println(name + "eat");
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Person(String name) {
        this.name = name;
    }

    public Person() {
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    //像将姓名隐藏起来，则用private修饰，外部不能直接访问

//构造方法快捷键
}

//静态和非静态谁的权限比较大？？
//如果是在被使用方面：静态的权限比较大，静态既可以被静态的使用，也可以被非静态的使用，但是非静态的只能被非静态的使用，不能被静态的使用
//如果是使用别人方面，非静态的权限比较大，非静态可以用静态的，也可以用非静态的，静态的可以用静态的，不可以用非静态的


//1---静态成员变量，不属于对象1，所以不用通过对象的引用来访问，可以直接通过类名来访问
//2---只要是非静态的成员变量和成员方法，都需要通过对象的引用才能调用
//3---在静态方法内部，不能直接使用非静态的数据成员，因为非静态方法依赖于对象，在调用静态方法时，并没有实例化对象
//所以并不是所有的成员方法都会有饮食参数tis，只有非静态的成员方法才会有隐式参数this
//4---静态方法里面是不能使用this的，因为根本没有this
//5---普通非静态方法可以使用静态方法
//6---静态变量最好被静态方式调用（静态的最好放在静态里头）
//静态成员本身可以直接通过类调用1，如果放在非静态的方法，则需要1创建对象通过对象调用，多此一举有
//直接放在静态方法，直接通过类调用




class T {
    public String name;
    public static int age;

    public static int size;
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public static int getAge() {
        return age;
    }

    public static void setAge(int age) {
        T.age = age;
    }

    public static void talk() {
       // System.out.println(this.name);//静态方法里面只能用静态成员
    }

    public void talk2() {
        System.out.println(this.name);
        System.out.println(this.age);
        this.talk2();
    }

    public T(String name,int size) {
        this.name = name;
        this.size = size;

    }

    public static void main(String[] args) {
        T t = new T("haha",10);
        System.out.println(t.size);
    }
}


//static成员变量初始化
//对于静态成员变量的初始化
//就地初始化
//默认初始化
//构造方法初始化,但是不建议这样做，静态变量属于类，不应该将size的控制权交给具体的对象
//而应该是属于类
//get和set方法初始化
//代码块初始化

//代码块
//普通代码块：定义在方法内部的代码块
//构造代码块/实例块/
//静态代码块


class P {
    public static String name = "haha";//非静态字段和非静态代码块的执行顺寻由定义顺序决定，谁先定义，谁先执行

    {

        System.out.println("构造代码块--》初始化非静态成员");
        name = "hehe";
    }

    //可以简单认为，将非静态字段和非静态代码块放在构造方法最前面
    //所以构造方法最后执行
    static {
        name = "haihai";
        System.out.println("wuhuwuhuwuhuwuhu");
        System.out.println("wuhuwuhuwuhuwuhu");
        System.out.println("wuhuwuhuwuhuwuhu");

        //只要类被加载，静态代码块就会被执行，不需要new对象就会执行
        //静态代码块一定只执行一次，在第一次加载类的时候执行，后面不再执行

    }

    public static void pp() {

    }
    public P() {
        System.out.println("无参构造");
    }
    public static void main(String[] args) {
        P p = new P();
        System.out.println(p.name);
        P.pp();
    }

}


//静态的一定优先非静态的执行

//执行顺序：
// 1---静态先父类静态块，子类静态代码块
// 2---非静态  父类构造块 构造方法
// 3---子类构造块 构造方法




